package com.hnit.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.hnit.mapper.CartMapper;
import com.hnit.service.CartService;
import com.hnit.service.ProductService; // 假设你有 ProductService 来获取商品详情
import com.hnit.web.Clients.IdServiceClient;
import com.hnit.web.DTO.CartDTO;
import com.hnit.web.DTO.ProductDTO; // 假设你有 ProductDTO
import com.hnit.web.Utils.ResponseResult;
import com.hnit.web.bean.Cart;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 嘿嘿
 * @description 购物车服务接口实现
 * @date 2025-08-01
 */
@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private ProductService productService; // 假设 ProductService 可用，用于获取商品详情

    @Autowired
    private IdServiceClient idGeneratorApi;

    /**
     * 将商品添加到指定用户的购物车.
     * <p>
     * 如果该商品已存在于用户的购物车中，则更新其数量；
     * 如果不存在，则新增一条购物车记录。
     *
     * @param userId    用户ID，用于标识是哪个用户的购物车
     * @param productId 商品ID，要添加到购物车的商品
     * @param quantity  要添加的数量
     * @return 添加或更新后的购物车项的DTO表示
     */
    @Override
    @Transactional
    public CartDTO addItemToCart(Long userId, Long productId, Integer quantity) {
        // 1. 检查购物车中是否已存在该商品
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId)
                .eq(Cart::getProductId, productId);
        Cart existingCartItem = cartMapper.selectOne(queryWrapper);

        Cart resultCart; // 用于存储最终的购物车项

        if (existingCartItem != null) {
            // 2. 如果存在，则更新数量
            int newQuantity = existingCartItem.getQuantity() + quantity;
            LambdaUpdateWrapper<Cart> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(Cart::getCartId, existingCartItem.getCartId())
                    .set(Cart::getQuantity, newQuantity);
            int updateResult = cartMapper.update(null, updateWrapper);
            if (updateResult == 0) {
                throw new RuntimeException("更新购物车商品数量失败");
            }
            // 更新成功后，重新查询以获取最新数据（或者直接修改existingCartItem的quantity并使用）
            resultCart = cartMapper.selectById(existingCartItem.getCartId());
        } else {
            // 3. 如果不存在，则新增购物车记录
            Cart newCartItem = new Cart();

            // 生成购物车ID
            ResponseResult rr = this.idGeneratorApi.getNextId();
            if (rr.getCode() != 1) {
                throw new RuntimeException("购物车ID生成失败");
            }
            Long cartId = Long.parseLong(rr.getData().toString());

            newCartItem.setCartId(cartId);
            newCartItem.setUserId(userId);
            newCartItem.setProductId(productId);
            newCartItem.setQuantity(quantity);
            int insertResult = cartMapper.insert(newCartItem);
            if (insertResult == 0) { // 应该检查插入结果是否为0表示失败
                throw new RuntimeException("添加商品到购物车失败");
            }
            resultCart = newCartItem; // 使用新创建的购物车项
        }

        // 转换并返回 CartDTO
        CartDTO cartDTO = new CartDTO();
        if (resultCart != null) {
            BeanUtils.copyProperties(resultCart, cartDTO);
            // 填充商品详情，与 listCartItems 逻辑一致
            ProductDTO product = productService.getProductById(resultCart.getProductId());
            if (product != null) {
                cartDTO.setProductName(product.getProductName());
                cartDTO.setPrice(product.getPrice());
                cartDTO.setOriginalPrice(product.getOriginalPrice());
                cartDTO.setMainImage(product.getMainImage());
            }
        }
        return cartDTO;
    }

    /**
     * 获取指定用户购物车中的所有商品列表.
     * <p>
     * 返回的是CartDTO列表，其中包含了详细的商品信息（如商品名、价格、图片等），
     * 以便在前端页面进行展示。
     *
     * @param userId 用户ID
     * @return 包含购物车商品详细信息的 DTO 列表
     */
    @Override
    public List<CartDTO> listCartItems(Long userId) {
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId)
                .orderByDesc(Cart::getCartId); // 按购物车ID或创建时间降序排序

        List<Cart> cartItems = cartMapper.selectList(queryWrapper);

        // 将 Cart 实体转换为 CartDTO 并用商品详情丰富
        List<CartDTO> cartDTOs = new ArrayList<>();
        for (Cart cartItem : cartItems) {
            CartDTO cartDTO = new CartDTO();
            BeanUtils.copyProperties(cartItem, cartDTO);

            // 使用 ProductService 获取商品详情
            ProductDTO product = productService.getProductById(cartItem.getProductId());
            if (product != null) {
                cartDTO.setProductName(product.getProductName());
                cartDTO.setPrice(product.getPrice());
                cartDTO.setOriginalPrice(product.getOriginalPrice());
                cartDTO.setMainImage(product.getMainImage());
                // 根据需要设置其他与商品相关的字段
            }
            cartDTOs.add(cartDTO);
        }
        return cartDTOs;
    }

    /**
     * 更新购物车中某条记录的商品数量.
     *
     * @param cartId   购物车的唯一ID
     * @param quantity 更新后的新数量
     * @return 是否更新成功
     */
    @Override
    @Transactional
    public boolean updateItemQuantity(Long cartId, Integer quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("商品数量必须大于0");
        }
        LambdaUpdateWrapper<Cart> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Cart::getCartId, cartId)
                .set(Cart::getQuantity, quantity);

        int result = cartMapper.update(null, updateWrapper);
        return result > 0; // 返回是否更新成功
    }

    /**
     * 从购物车中移除单个商品.
     *
     * @param cartId 要移除的购物车记录的唯一ID
     * @return 是否移除成功
     */
    @Override
    @Transactional
    public boolean removeItemFromCart(Long cartId) {
        int result = cartMapper.deleteById(cartId);
        return result > 0; // 返回是否移除成功
    }

    /**
     * 批量从购物车中移除多个商品.
     *
     * @param cartIds 要移除的购物车记录ID的列表
     * @return 是否批量移除成功
     */
    @Override
    @Transactional
    public boolean removeItemsFromCart(List<Long> cartIds) {
        if (cartIds == null || cartIds.isEmpty()) {
            return true; // 没有要移除的，视为成功
        }
        // MyBatis-Plus 提供了 deleteBatchIds 方法
        int result = cartMapper.deleteBatchIds(cartIds);
        // 如果删除的数量与请求的数量不一致，可能存在部分失败
        if (result != cartIds.size()) {
            System.err.println("警告：并非所有指定的购物车商品都被移除。已移除: " + result + ", 请求移除: " + cartIds.size());
            // 根据业务需求，这里可以选择抛出异常或返回 false
            // throw new RuntimeException("部分商品移除失败");
        }
        return result > 0; // 只要有删除成功就返回true，或根据需求判断 result == cartIds.size()
    }

    /**
     * 清空指定用户的所有购物车项.
     * <p>
     * 通常在用户成功下单后调用此方法。
     *
     * @param userId 用户ID
     * @return 是否清空成功
     */
    @Override
    @Transactional
    public boolean clearCart(Long userId) {
        LambdaQueryWrapper<Cart> deleteWrapper = new LambdaQueryWrapper<>();
        deleteWrapper.eq(Cart::getUserId, userId);
        int result = cartMapper.delete(deleteWrapper);
        // 如果结果为 0，表示购物车已为空，也视为成功清空
        return true; // 返回 true 表示操作执行完成
    }

    /**
     * 获取用户购物车中的商品项总数（不是商品总数量）.
     * <p>
     * 例如，购物车里有2本书和3支笔，此方法返回2。
     * 通常用于在页面的购物车图标上显示角标。
     *
     * @param userId 用户ID
     * @return 购物车中的项目种类数量
     */
    @Override
    public Integer getCartItemCount(Long userId) {
        LambdaQueryWrapper<Cart> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Cart::getUserId, userId);
        // count 方法返回匹配查询的记录数
        Long count = cartMapper.selectCount(queryWrapper);
        return count != null ? Math.toIntExact(count) : 0;
    }
}